package com.booksystem.campuslibrarymanagementsystem.controller.admin;


import com.booksystem.campuslibrarymanagementsystem.commen.request.adminrequest.BookManagement.*;
import com.booksystem.campuslibrarymanagementsystem.commen.result.Result;
import com.booksystem.campuslibrarymanagementsystem.commen.result.Verifys;
import com.booksystem.campuslibrarymanagementsystem.commen.result.adminresult.BookManagementR.BookselectR;
import com.booksystem.campuslibrarymanagementsystem.entity.BooksTable;
import com.booksystem.campuslibrarymanagementsystem.entity.CategoriesTable;
import com.booksystem.campuslibrarymanagementsystem.service.AccountTableService;
import com.booksystem.campuslibrarymanagementsystem.service.BooksTableService;
import com.booksystem.campuslibrarymanagementsystem.service.CategoriesTableService;
import com.booksystem.campuslibrarymanagementsystem.utils.AuditUtil;
import com.booksystem.campuslibrarymanagementsystem.utils.TimeUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/Admin")
@Api(tags = "图书管理")
public class BookManagementController {
    private final String idt = "admin";

    Verifys verifys = new Verifys();
    BooksTable booksTable = new BooksTable();
    CategoriesTable categoriesTable = new CategoriesTable();
    @Autowired
    private AccountTableService accountTableService;
    @Autowired
    private BooksTableService booksTableService;
    @Autowired
    private CategoriesTableService categoriesTableService;


    /**
     * 1.图书录入。
     *
     * @return Result.success();or return Result.fail();
     * @RequestBody Announcementlist（token，title，author，category，totalcopies）
     * 1.解析获得的token值，并保存到键值对Map-parsed中
     * 2.判断parsed是否为null
     * 3.null：返回失败信息-请输入正确token值。不为null：判断解析到的身份码是否为admin。
     * 4.不为admin；返回失败信息-身份权限不足。是admin：判断解析到的学号是否在account表中存在。
     * 5.不存在：返回失败信息-该学号不存在。存在：判断totalcopies是否大于等于0
     * 6.否：返回失败信息-数量不可能为负数，是：判断是否存在category这个类别
     * 7.不存在：返回失败信息-"没有找到" + bookadd.getCategory() + "此类别"。存在：判断是否已经存在title这本书
     * 8.存在：返回失败信息-"已经存在书名为" + bookadd.getTitle() + "的图书"。不存在：获取booksTable数据中最后一条数据id，判断id是否为空
     * 9.为空：不做改变。不为空：id+1
     * 10.将前端给的数据保存至booksTable对象中并保存到数据库，之后返回一个布尔值a
     * 11.a=false：返回失败信息-录入失败，a=true：保存成功-已成功录入
     */
    @PostMapping("/booksAdd")
    @ApiOperation(value = "图书录入", notes = "录入图书")
    public Result booksAdd(@RequestBody Bookadd bookadd) {
        verifys = AuditUtil.verifyUtil(bookadd.getToken(),"admin",accountTableService);
        switch (verifys.getMsg()) {
            case "成功":
                if (bookadd.getTotalcopies() >= 0) {
                    categoriesTable = categoriesTableService.queryByCategoryName(bookadd.getCategory());
                    if (categoriesTable != null) {
                        BooksTable booksTable1 = booksTableService.queryByTitle(bookadd.getTitle());
                        if (booksTable1 == null) {
                            int i = 0;
                            BooksTable booksTable2 = booksTableService.selectLastBookid();
                            if (booksTable2 != null) {
                                i = booksTable2.getBookid() + 1;
                            }
                            booksTable.setBookid(i);
                            booksTable.setTitle(bookadd.getTitle());
                            booksTable.setAuthor(bookadd.getAuthor());
                            booksTable.setCategory(bookadd.getCategory());
                            booksTable.setTotalcopies(bookadd.getTotalcopies());
                            booksTable.setAvailablecopies(0);
                            booksTable.setCreatedat(TimeUtil.getTime());
                            boolean a = booksTableService.save(booksTable);
                            if (a) {
                                System.out.println("图书录入成功");
                                return Result.success("已成功录入", bookadd.getTotalcopies());
                            } else {
                                return Result.fail("录入失败");
                            }
                        } else {
                            return Result.fail("已经存在书名为" + bookadd.getTitle() + "的图书");
                        }
                    } else {
                        return Result.fail("没有找到" + bookadd.getCategory() + "此类别");
                    }
                } else {
                    return Result.fail("数量不可能为负数");
                }

            default:
                return Result.fail(verifys.getMsg());
        }
    }

    /**
     * 2.图书修改。
     *
     * @return Result.success();or return Result.fail();
     * @RequestBody Booksupdate（token，bookid，title，author，category）
     * 1.解析获得的token值，并保存到键值对Map-parsed中
     * 2.判断parsed是否为null
     * 3.null：返回失败信息-请输入正确token值。不为null：判断解析到的身份码是否为admin。
     * 4.不为admin；返回失败信息-身份权限不足。是admin：判断解析到的学号是否在account表中存在。
     * 5.不存在：返回失败信息-该学号不存在。存在：查询是否存在id为bookid的书
     * 6，不存在：返回失败信息-"没有找到id为" + booksupdate.getBookid() + "的book"。存在：判断是否存在相同图书名title
     * 通过ID查询现有图书：
     * booksTable = booksTableService.queryById(booksupdate.getBookid());
     * 这一行是通过提供的图书ID来查询数据库中是否存在该图书。
     * 检查图书是否存在：
     * 如果查询结果不为空（即找到了该图书）：
     * 进行下一步操作。
     * 通过标题查询图书：
     * BooksTable booksTable1 = booksTableService.queryByTitle(booksupdate.getTitle());
     * 这一行是通过新的图书标题来查询数据库中是否已存在同名的图书。
     * 检查是否有同名图书：
     * 如果没有找到同名的图书（booksTable1 == null）：
     * 进入类别验证步骤。
     * 如果找到了同名的图书：
     * 检查这个同名的图书是否就是我们要更新的那个图书（通过比较图书ID）。
     * 如果是同一个图书，则继续执行类别验证步骤。
     * 如果不是同一个图书，则返回错误信息，提示“已经存在图书名为《booksupdate.getTitle()》的图书”。
     * 验证类别是否存在：
     * categoriesTable = categoriesTableService.queryByCategoryName(booksupdate.getCategory());
     * 这一行是通过新的图书类别名称来查询该类别是否存在于系统中。
     * 如果找到了该类别，则继续执行更新操作。
     * 如果没有找到该类别，则返回错误信息，提示“没有找到booksupdate.getCategory()此类别”。
     * 执行图书信息更新操作：
     * boolean a = booksTableService.upDataBook(booksupdate.getBookid(), booksupdate.getTitle(), booksupdate.getAuthor(), booksupdate.getCategory());
     * 使用图书ID、新的标题、作者和类别来更新图书信息。
     * 如果更新成功（a为true），则返回成功信息，“修改成功”。
     * 如果更新失败（a为false），则返回错误信息，“修改失败”。
     * 处理未找到图书的情况：
     * 如果最开始查询图书时没有找到对应ID的图书，则返回错误信息，“没有找到id为booksupdate.getBookid()的book”。
     */
    @PostMapping("/booksUpdate")
    @ApiOperation(value = "图书修改", notes = "修改图书名称，作者，类别")
    public Result booksUpdate(@RequestBody Booksupdate booksupdate) {
        verifys = AuditUtil.verifyUtil(booksupdate.getToken(),"admin",accountTableService);
        switch (verifys.getMsg()) {
            case "成功":
                booksTable = booksTableService.queryById(booksupdate.getBookid());
                if (booksTable != null) {
                    BooksTable booksTable1 = booksTableService.queryByTitle(booksupdate.getTitle());
                    if (booksTable1 == null) {
                        return bookUpdata(booksupdate);
                    } else {
                        if (booksTable1.getBookid() == booksupdate.getBookid()) {
                           return bookUpdata(booksupdate);
                        } else {
                            return Result.fail("已经存在图书名为《" + booksupdate.getTitle() + "》的图书");
                        }
                    }
                } else {
                    return Result.fail("没有找到id为" + booksupdate.getBookid() + "的book");
                }
            default:
                return Result.fail(verifys.getMsg());
        }
    }
    public Result bookUpdata(Booksupdate booksupdate){
    categoriesTable = categoriesTableService.queryByCategoryName(booksupdate.getCategory());
    if (categoriesTable != null) {
        boolean a = booksTableService.upDataBook(booksupdate.getBookid(), booksupdate.getTitle(), booksupdate.getAuthor(), booksupdate.getCategory());
        if (a) {
            System.out.println("图书" + booksupdate.getTitle() +"修改成功");
            return Result.success("修改成功", 1);
        } else {
            return Result.fail("修改失败");
        }
    } else {
        return Result.fail("没有找到" + booksupdate.getCategory() + "此类别");
    }
}


    /**
     * 3.图书清理。
     *
     * @return Result.success();or return Result.fail();
     * @RequestBody Bookdeleted（token，bookid）
     * 1.解析获得的token值，并保存到键值对Map-parsed中
     * 2.判断parsed是否为null
     * 3.null：返回失败信息-请输入正确token值。不为null：判断解析到的身份码是否为admin。
     * 4.不为admin；返回失败信息-身份权限不足。是admin：判断解析到的学号是否在account表中存在。
     * 5.不存在：返回失败信息-该学号不存在。存在：查询是否存在bookid这本书
     * 6.不存在：返回失败信息-"没有找到id为" + bookdeleted.getBookid() + "的book"。存在：进行删除，并返回布尔值a
     * 7.a=false：返回失败信息-删除失败，a=true：返回成功信息-删除成功
     */
    @PostMapping("/bookDeleted")
    @ApiOperation(value = "图书清理", notes = "根据图书id清理图书")
    public Result bookDeleted(@RequestBody Bookdeleted bookdeleted) {
        verifys = AuditUtil.verifyUtil(bookdeleted.getToken(),"admin",accountTableService);
        switch (verifys.getMsg()) {
            case "成功":
                booksTable = booksTableService.queryById(bookdeleted.getBookid());
                if (booksTable != null) {
                    boolean a = booksTableService.deleteByBookid(bookdeleted.getBookid());
                    if (a) {
                        System.out.println(bookdeleted.getBookid() + "  删除成功");
                        return Result.success("删除成功", 1);
                    } else {
                        return Result.fail("删除失败");
                    }
                } else {
                    return Result.fail("没有找到id为" + bookdeleted.getBookid() + "的book");
                }
            default:
                return Result.fail(verifys.getMsg());
        }
    }

    /**
     * 4图书查询。
     *
     * @return Result.success();or return Result.fail();
     * @RequestBody Bookselect（token，bookid，title，author，category）
     * 1.解析获得的token值，并保存到键值对Map-parsed中
     * 2.判断parsed是否为null
     * 3.null：返回失败信息-请输入正确token值。不为null：判断解析到的身份码是否为admin。
     * 4.不为admin；返回失败信息-身份权限不足。是admin：判断解析到的学号是否在account表中存在。
     * 5.不存在：返回失败信息-该学号不存在。
     * 6.存在：检查图书类别是否为空：
     * if (bookselect.getCategory().isEmpty()) {
     * 判断用户输入的图书类别是否为空或未提供。
     * 如果图书类别为空：
     * 执行无类别限制的查询：
     * List<BooksTable> list = booksTableService.selectList(bookselect.getBookid(), bookselect.getTitle(), bookselect.getAuthor(), bookselect.getCategory());
     * 调用selectList方法，传入图书ID、标题、作者和空类别来进行查询。这里假设selectList方法可以接受一个空的类别参数，并能正确处理这种情形。
     * 如果查询到的结果列表不为空：
     * 遍历查询结果并封装成BookselectR对象列表。
     * 创建ArrayList<BookselectR>类型的list1。
     * 对于每一个查询结果中的BooksTable对象：
     * 创建一个BookselectR对象，并设置其属性（如图书ID、标题、作者、类别和总副本数等）。
     * 将这个BookselectR对象添加到list1中。
     * 返回一个成功的结果，其中包含转换后的BookselectR对象列表及其大小。
     * 如果查询结果列表为空：
     * 返回一个失败的结果，提示“没有找到符合的图书信息”。
     * 如果图书类别不为空：
     * 验证输入的图书类别是否存在：
     * CategoriesTable categoriesTable = categoriesTableService.queryByCategoryName(bookselect.getCategory());
     * 使用输入的图书类别名称查询对应的类别。
     * 如果找到了该类别：
     * 执行与类别相关的查询：
     * List<BooksTable> list = booksTableService.selectList(bookselect.getBookid(), bookselect.getTitle(), bookselect.getAuthor(), bookselect.getCategory());
     * 同样调用selectList方法，但这次会传入具体的类别参数。
     * 如果查询结果列表不为空：
     * 遍历查询结果并封装成BookselectR对象列表。
     * 返回一个成功的结果，其中包含转换后的BookselectR对象列表及其大小。
     * 如果查询结果列表为空：
     * 返回一个失败的结果，提示“没有找到符合的图书信息”。
     * 如果没有找到该类别：
     * 返回一个失败的结果，提示“该图书类别并没有”。
     */
    @PostMapping("/bookSelect")
    @ApiOperation(value = "图书查询", notes = "根据图书id,名称，作者，类别查询图书")
    public Result<List<BookselectR>> bookSelect(@RequestBody Bookselect bookselect) {
        verifys = AuditUtil.verifyUtil(bookselect.getToken(),"admin",accountTableService);
        switch (verifys.getMsg()) {
            case "成功":
                if (bookselect.getCategory().isEmpty()) {
                    return getListResult(bookselect);
                } else {
                    CategoriesTable categoriesTable = categoriesTableService.queryByCategoryName(bookselect.getCategory());
                    if (categoriesTable != null) {
                        return getListResult(bookselect);
                    } else {
                        return Result.fail("该图书类别并没有");
                    }
                }
            default:
                return Result.fail(verifys.getMsg());
        }
    }
    private Result<List<BookselectR>> getListResult(@RequestBody Bookselect bookselect) {
        List<BooksTable> list = booksTableService.selectList(bookselect.getBookid(), bookselect.getTitle(), bookselect.getAuthor(), bookselect.getCategory());
        if (!list.isEmpty()) {
            ArrayList<BookselectR> list1 = new ArrayList<>();
            for (int i = 0; i < list.size(); i++) {
                booksTable = list.get(i);
                BookselectR bookselectR = new BookselectR();
                bookselectR.setBookid(booksTable.getBookid());
                bookselectR.setTitle(booksTable.getTitle());
                bookselectR.setAuthor(booksTable.getAuthor());
                bookselectR.setCategory(booksTable.getCategory());
                bookselectR.setTotalcopies(booksTable.getTotalcopies());
                list1.add(bookselectR);
            }
            System.out.println("图书查询成功");
            return Result.success(list1, list1.size());
        } else {
            return Result.fail("没有找到符合的图书信息");
        }
    }

    /**
     * 5.图书列表。
     *
     * @return Result.success();or return Result.fail();
     * @RequestBody Booklist（token）
     * 1.解析获得的token值，并保存到键值对Map-parsed中
     * 2.判断parsed是否为null
     * 3.null：返回失败信息-请输入正确token值。不为null：判断解析到的身份码是否为admin。
     * 4.不为admin；返回失败信息-身份权限不足。是admin：判断解析到的学号是否在account表中存在。
     * 5.不存在：返回失败信息-该学号不存在。存在：查询出所有图书类别并保存到List<BooksTable> list中，判断list是否为空
     * 6.为空：返回失败信息-暂时没有数据，不为空：进行数据筛除，保存一些信息并保存到list1中
     * 7.发送list1到前端
     */
    @PostMapping("/bookList")
    @ApiOperation(value = "图书列表", notes = "总列表")
    public Result<List<BookselectR>> bookList(@RequestBody Booklist booklist) {
        verifys = AuditUtil.verifyUtil(booklist.getToken(),"admin",accountTableService);
        switch (verifys.getMsg()) {
            case "成功":
                List<BooksTable> list = booksTableService.list();
                if (!list.isEmpty()) {
                    ArrayList<BookselectR> list1 = new ArrayList<>();
                    for (int i = 0; i < list.size(); i++) {
                        booksTable = list.get(i);
                        BookselectR bookselectR = new BookselectR();
                        bookselectR.setBookid(booksTable.getBookid());
                        bookselectR.setTitle(booksTable.getTitle());
                        bookselectR.setAuthor(booksTable.getAuthor());
                        bookselectR.setCategory(booksTable.getCategory());
                        bookselectR.setTotalcopies(booksTable.getTotalcopies());
                        list1.add(bookselectR);
                    }
                    System.out.println("图书总列表发送成功");
                    return Result.success(list1, list1.size());
                } else {
                    return Result.fail("暂时没有数据");
                }
            default:
                return Result.fail(verifys.getMsg());
        }
    }



}
